TPK algorithm

 ( 1977 In Computing ) 

TPK: begin integer i; real y; real array a0:10;

  real procedure f(t); real t; value t;
     f := sqrt(abs(t)) + 5 × t ↑ 3;
  for i := 0 step 1 until 10 do read(a[i]);
  for i := 10 step -1 until 0 do
  begin y := f(a[i]);
     if y > 400 then write(i, 'TOO LARGE')
                else write(i, y);
  end
     

As many of the early high-level languages could not handle the TPK algorithm exactly, they allow the following modifications:

• If the language supports only integer variables, then assume that all inputs and outputs are integer-valued, and that sqrt(x) means the largest integer not exceeding $\backslash sqrt\{x\}$.

• If the language does not support alphabetic output, then instead of the string 'TOO LARGE', output the number 999.

• If the language does not allow any input and output, then assume that the 11 input values $a\_0,\; a\_1,\; \backslash ldots,\; a\_\{10\}$ have been supplied by an external process somehow, and the task is to compute the 22 output values $10,\; f(10),\; 9,\; f(9),\; \backslash ldots,\; 0,\; f(0)$ (with 999 replacing too-large values of $f(i)$).

• If the language does not allow programmers to define their own functions, then replace f(a[i]) with an expression equivalent to $\backslash sqrt$ + 5x^3.

With these modifications when necessary, the authors implement this algorithm in Konrad Zuse's Plankalkül, in Herman Goldstine and von Neumann's Flowchart, in Haskell Curry's proposed notation, in Short Code of John Mauchly and others, in the Intermediate Program Language of Arthur Burks, in the notation of Heinz Rutishauser, in the language and compiler by Corrado Böhm in 1951–52, in Autocode of Alick Glennie, in the A-2 system of Grace Hopper, in the Laning and Zierler system, in the earliest proposed Fortran (1954) of John Backus, in the Autocode for Mark 1 by Tony Brooker, in ПП-2 of Andrey Ershov, in BACAIC of Mandalay Grems and R. E. Porter, in Kompiler 2 of A. Kenton Elsworth and others, in ADES of E. K. Blum, the Internal Translator of Alan Perlis, in Fortran of John Backus, in ARITH-MATIC and MATH-MATIC from Grace Hopper's lab, in the system of Bauer and Klaus Samelson, and (in addenda in 2003 and 2009) PACT I and TRANSCODE. They then describe what kind of arithmetic was available, and provide a subjective rating of these languages on parameters of "implementation", "readability", "control structures", "data structures", "machine independence" and "impact", besides mentioning what each was the first to do.

1. include
2. include

double f(double t) {

   return sqrt(fabs(t)) + 5 * pow(t, 3);
     

int main(void) {

   double a[11] = {0}, y;
   for (int i = 0; i < 11; i++)
       scanf("%lf", &a[i]);
     

   for (int i = 10; i >= 0; i--) {
       y = f(a[i]);
       if (y > 400)
           printf("%d TOO LARGE\n", i);
       else
           printf("%d %.16g\n", i, y);
   }
     

from math import sqrt

def f(t):

   return sqrt(abs(t)) + 5 * t**3
     

a = float(input()) for i, t in reversed(list(enumerate(a))):

   y = f(t)
   print(i, "TOO LARGE" if y > 400 else y)
     

use std::{io, iter};

fn f(t: f64) -> Option {

   let y = t.abs().sqrt() + 5.0 * t.powi(3);
   (y <= 400.0).then_some(y)
     

fn main() {

   let mut a = [0f64; 11];
   for (t, input) in iter::zip(&mut a, io::stdin().lines()) {
       *t = input.unwrap().parse().unwrap();
   }
     

   a.iter().enumerate().rev().for_each(|(i, &t)| match f(t) {
       None => println!("{i} TOO LARGE"),
       Some(y) => println!("{i} {y}"),
   });
     

• Implementations in many languages at Rosetta Code
• Implementations in several languages